// 1.原型链继承
function Parent() {
  this.name = ['xx', 'kk']
}

Parent.prototype.getName = function() {
  console.log(this.name) 
}

function Child() {

}
Child.prototype = new Parent()


var child1 = new Child();

console.log(child1.getName())

// 产生的问题就是
// 1.引用类型的属性被所有实例共享
// 2.在创建 Child 的实例时，不能向Parent传参


// 2.借用构造函数(经典继承)
function Child() {
  Parent.call(this)
}
// 缺点是  方法都在构造函数中定义，每次创建实例都会创建一遍方法。



// 3.组合继承
function Child() {
  Parent.call(this)
}
Child.prototype = new Parent()
Child.prototype.constructor = Child;



// 4.原型式继承
function createObj(o) {
  function F(){}
  F.prototype = o;
  return new F();
}
var person = {
  name: 'kevin',
  friends: ['daisy', 'kelly']
}

var person1 = createObj(person);
var person2 = createObj(person);

person1.name = 'person1';
console.log(person2.name); // kevin

person1.friends.push('taylor');
console.log(person2.friends); // ["daisy", "kelly", "taylor"]

// 包含引用类型的属性值始终都会共享相应的值，这点跟原型链继承一样。



// 最终的方法就是
// 避免  Parent 构造函数两次调用
// 核心就是   如果我们不使用 Child.prototype = new Parent() ，而是间接的让 Child.prototype 访问到 Parent.prototype 呢？
function object(o) {
  function F() {}
  F.prototype = o;
  return new F();
}

function prototype(child, parent) {
  var prototype = object(parent.prototype);
  prototype.constructor = child;
  child.prototype = prototype;
}

// 当我们使用的时候：
prototype(Child, Parent);
